import { useUserStore, useAppStore } from "../store/hooks";

// 基础URL
let baseURL = "";

// 请求拦截器队列
const requestInterceptors = [];

// 响应拦截器队列
const responseInterceptors = [];

// 添加一个活跃请求计数器
let activeRequests = 0;

// 创建请求配置
const createConfig = (config) => {
  const appStore = useAppStore();
  const userStore = useUserStore();
  // 获取baseURL
  baseURL = appStore.appConfig.baseURL;

  // 默认配置
  const defaultConfig = {
    // 请求URL
    url: "",
    // 请求方法
    method: "GET",
    // 请求头
    header: {
      "Content-Type": "application/json",
    },
    // 请求数据
    data: {},
    // 超时时间
    timeout: 30000,
    // 是否显示加载提示
    loading: true,
    // 加载提示文本
    loadingText: "加载中...",
    // 是否显示错误提示
    showError: true,
  };

  // 合并配置
  const mergedConfig = {
    ...defaultConfig,
    ...config,
  };

  // 添加WeiXinId到请求数据
  if (userStore.userInfo && userStore.userInfo.WeiXinId) {
    mergedConfig.data.WeiXinId = userStore.userInfo.WeiXinId;
  }

  // 拼接完整URL
  if (!mergedConfig.url.startsWith("http")) {
    mergedConfig.url = baseURL + mergedConfig.url;
  }

  // 添加token
  if (userStore.token) {
    mergedConfig.header.Authorization = `Bearer ${userStore.token}`;
  }

  return mergedConfig;
};

// 执行请求拦截器
const executeRequestInterceptors = async (config) => {
  let currentConfig = config;
  console.log(111, currentConfig);
  //   if (userStore.userInfo && userStore.userInfo.WeiXinId) {
  //     currentConfig.data.WeiXinId = userStore.userInfo.WeiXinId;
  //   }

  for (const interceptor of requestInterceptors) {
    try {
      const result = await interceptor(currentConfig);
      if (result) {
        currentConfig = result;
      }
    } catch (error) {
      console.error("请求拦截器执行出错：", error);
    }
  }

  return currentConfig;
};

// 执行响应拦截器
const executeResponseInterceptors = async (response, config) => {
  let currentResponse = response;

  for (const interceptor of responseInterceptors) {
    try {
      const result = await interceptor(currentResponse, config);
      if (result) {
        currentResponse = result;
      }
    } catch (error) {
      console.error("响应拦截器执行出错：", error);
    }
  }

  return currentResponse;
};

// 处理请求
const handleRequest = async (config) => {
  return new Promise(async (resolve, reject) => {
    const appStore = useAppStore();

    try {
      // 执行请求拦截器
      const interceptedConfig = await executeRequestInterceptors(config);

      // 显示加载提示
      if (interceptedConfig.loading) {
        // 增加活跃请求计数
        activeRequests++;
        if (activeRequests === 1) {
          // 只有从0变为1时才显示loading
          appStore.setLoading(true);
          uni.showLoading({
            title: interceptedConfig.loadingText,
            mask: true,
          });
        }
      }

      // 发送请求
      uni.request({
        ...interceptedConfig,
        success: async (res) => {
          // 请求成功
          if (res.statusCode >= 200 && res.statusCode < 300) {
            // 执行响应拦截器
            const interceptedResponse = await executeResponseInterceptors(
              res.data,
              interceptedConfig
            );
            resolve(interceptedResponse);
          } else {
            // 请求失败处理
            handleError(res, interceptedConfig, reject);
          }
        },
        fail: (err) => {
          // 请求错误处理
          handleError(err, interceptedConfig, reject);
        },
        complete: () => {
          // 隐藏加载提示
          if (interceptedConfig.loading) {
            // 减少活跃请求计数
            activeRequests--;
            if (activeRequests === 0) {
              // 只有当所有请求都完成时才隐藏loading
              appStore.setLoading(false);
              uni.hideLoading();
            }
          }
        },
      });
    } catch (error) {
      // 拦截器异常处理
      handleError(error, config, reject);

      // 隐藏加载提示
      if (config.loading) {
        // 减少活跃请求计数
        activeRequests--;
        if (activeRequests === 0) {
          // 只有当所有请求都完成时才隐藏loading
          appStore.setLoading(false);
          uni.hideLoading();
        }
      }
    }
  });
};

// 处理错误
const handleError = (err, config, reject) => {
  const statusCode = err.statusCode || err.status || 0;
  let errMsg = err.errMsg || err.data?.message || "请求失败";

  // 权限错误处理
  if (statusCode === 401) {
    // 清除登录信息
    const userStore = useUserStore();
    userStore.logout();

    // 跳转登录页
    uni.navigateTo({
      url: "/pages/login/index",
    });

    errMsg = "登录已过期，请重新登录";
  }

  // 显示错误提示
  if (config.showError) {
    uni.showToast({
      title: errMsg,
      icon: "none",
      duration: 2000,
    });
  }

  reject({
    statusCode,
    message: errMsg,
    data: err.data,
  });
};

// 请求函数
const request = {
  /**
   * 添加请求拦截器
   * @param {Function} interceptor 拦截器函数，接收config参数，返回修改后的config
   */
  addRequestInterceptor(interceptor) {
    if (typeof interceptor === "function") {
      requestInterceptors.push(interceptor);
    }
  },

  /**
   * 添加响应拦截器
   * @param {Function} interceptor 拦截器函数，接收response和config参数，返回修改后的response
   */
  addResponseInterceptor(interceptor) {
    if (typeof interceptor === "function") {
      responseInterceptors.push(interceptor);
    }
  },

  /**
   * 清除所有拦截器
   */
  clearInterceptors() {
    requestInterceptors.length = 0;
    responseInterceptors.length = 0;
  },

  /**
   * GET请求
   * @param {String} url 请求地址
   * @param {Object} data 请求参数
   * @param {Object} options 请求配置
   */
  get(url, data = {}, options = {}) {
    return handleRequest(
      createConfig({
        url,
        method: "GET",
        data,
        ...options,
      })
    );
  },

  /**
   * POST请求
   * @param {String} url 请求地址
   * @param {Object} data 请求参数
   * @param {Object} options 请求配置
   */
  post(url, data = {}, options = {}) {
    return handleRequest(
      createConfig({
        url,
        method: "POST",
        data,
        ...options,
      })
    );
  },

  /**
   * PUT请求
   * @param {String} url 请求地址
   * @param {Object} data 请求参数
   * @param {Object} options 请求配置
   */
  put(url, data = {}, options = {}) {
    return handleRequest(
      createConfig({
        url,
        method: "PUT",
        data,
        ...options,
      })
    );
  },

  /**
   * DELETE请求
   * @param {String} url 请求地址
   * @param {Object} data 请求参数
   * @param {Object} options 请求配置
   */
  delete(url, data = {}, options = {}) {
    return handleRequest(
      createConfig({
        url,
        method: "DELETE",
        data,
        ...options,
      })
    );
  },
};

export default request;
